import os
import shutil
import time
import logging
import datetime

class DirectorySync:
    def __init__(self, source_dir, target_dir):
        """
        初始化目录同步类
        :param source_dir: 源目录路径（目录1）
        :param target_dir: 目标目录路径（目录2）
        """
        self.source_dir = source_dir
        self.target_dir = target_dir
        
        # 配置日志
        logging.basicConfig(
            level=logging.INFO, 
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler("sync_databack_" + datetime.datetime.now().strftime("%Y%m%d%H%M%S") + ".log"),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)
        
    def sync_directories(self):
        """
        执行目录同步操作，从源目录同步到目标目录
        :return: 同步结果（成功/失败）
        """
        try:
            # 检查源目录是否存在
            if not os.path.exists(self.source_dir):
                self.logger.error(f'源目录不存在: {self.source_dir}')
                return False
            
            # 确保目标目录存在
            if not os.path.exists(self.target_dir):
                self.logger.info(f'创建目标目录: {self.target_dir}')
                os.makedirs(self.target_dir)
            
            # 开始同步
            self.logger.info(f'开始从 {self.source_dir} 同步到 {self.target_dir}')
            start_time = time.time()
            
            # 统计信息
            stats = {
                'total_files': 0,
                'copied_files': 0,
                'failed_files': 0,
                'total_dirs': 0,
                'created_dirs': 0
            }
            
            # 递归同步
            self._sync_recursive(self.source_dir, self.target_dir, stats)
            
            end_time = time.time()
            
            # 输出统计信息
            self.logger.info(f'同步完成！耗时: {end_time - start_time:.2f} 秒')
            self.logger.info(f'总共 {stats["total_files"]} 个文件，复制了 {stats["copied_files"]} 个，失败 {stats["failed_files"]} 个')
            self.logger.info(f'总共 {stats["total_dirs"]} 个目录，创建了 {stats["created_dirs"]} 个')
            
            return True
        except Exception as e:
            self.logger.error(f'同步过程中发生错误: {e}')
            return False
    
    def _sync_recursive(self, source_path, target_path, stats):
        """
        递归同步源目录到目标目录
        :param source_path: 当前源目录路径
        :param target_path: 当前目标目录路径
        :param stats: 统计信息字典
        """
        try:
            # 遍历源目录
            for item in os.listdir(source_path):
                source_item = os.path.join(source_path, item)
                target_item = os.path.join(target_path, item)
                
                if os.path.isdir(source_item):
                    stats['total_dirs'] += 1
                    
                    # 检查目标目录中是否存在同名目录
                    if not os.path.exists(target_item):
                        self.logger.info(f'创建目录: {target_item}')
                        os.makedirs(target_item)
                        stats['created_dirs'] += 1
                    
                    # 递归同步子目录
                    self._sync_recursive(source_item, target_item, stats)
                elif os.path.isfile(source_item):
                    stats['total_files'] += 1
                    
                    # 检查目标目录中是否存在同名文件
                    if not os.path.exists(target_item):
                        try:
                            # 复制文件
                            shutil.copy2(source_item, target_item)
                            self.logger.info(f'复制文件: {source_item} -> {target_item}')
                            stats['copied_files'] += 1
                        except Exception as e:
                            self.logger.error(f'复制文件失败 {source_item}: {e}')
                            stats['failed_files'] += 1
        except Exception as e:
            self.logger.error(f'递归同步出错 {source_path}: {e}')
            stats['failed_files'] += 1
            
    def _delete_source_files(self):
        """
        删除源目录中的所有文件和子目录，但保留源目录本身
        :return: 删除操作是否成功
        """
        try:
            if not os.path.exists(self.source_dir):
                self.logger.warning(f'源目录不存在，无法删除: {self.source_dir}')
                return True
                
            self.logger.info(f'开始删除源目录中的所有文件和子目录: {self.source_dir}')
            
            # 记录删除的文件和目录数量
            deleted_files = 0
            deleted_dirs = 0
            
            # 遍历源目录中的所有项目
            for root, dirs, files in os.walk(self.source_dir, topdown=False):
                # 先删除文件
                for file in files:
                    file_path = os.path.join(root, file)
                    try:
                        os.remove(file_path)
                        deleted_files += 1
                    except Exception as e:
                        self.logger.error(f'删除文件失败 {file_path}: {e}')
                
                # 然后删除目录
                for dir_name in dirs:
                    dir_path = os.path.join(root, dir_name)
                    try:
                        os.rmdir(dir_path)
                        deleted_dirs += 1
                    except Exception as e:
                        self.logger.error(f'删除目录失败 {dir_path}: {e}')
            
            self.logger.info(f'源目录清理完成: 删除了 {deleted_files} 个文件和 {deleted_dirs} 个目录')
            return True
        except Exception as e:
            self.logger.error(f'删除源目录文件过程中发生错误: {e}')
            return False


def directorySync():
    """
    主函数，执行目录同步
    """
    # 配置源目录和目标目录
    # 默认使用upload1和upload目录作为示例
    SOURCE_DIR = 'E:/trae_project/spider3/upload/'
    TARGET_DIR = 'E:/trae_project/spider3/upload1/'
    
    # 创建同步实例
    dir_sync = DirectorySync(SOURCE_DIR, TARGET_DIR)
    
    # 执行同步
    success = dir_sync.sync_directories()
    
    if success:
        # 同步成功后，删除源目录中的所有文件
        # 等待页面加载
        print("提示22：等待5秒")
        time.sleep(5)
        delete_success = dir_sync._delete_source_files()
        if delete_success:
            print('目录同步成功完成，并已清空源目录')
        else:
            print('目录同步成功完成，但清空源目录时发生错误')
    else:
        print('目录同步失败')


if __name__ == '__main__':
    directorySync()